PC for Alla 2005 May/PC för Alla 0505.iso/fullversioner/realsoft3d/data1.cab/Scripting/scripts/js/real/code/r3curve.js

JavaScript | 2005-04-04 | 21.1 KB | 701 lines

// JavaScript wrapper for r3curve.h
// Auto generated file, do not modify by hand
// Copyright ⌐ 2004, Realsoft Graphics Oy

var R3_CURVE_H = 1;
include("oops/r3model.js")


var R3CLID_CURVE = 49;




// Description: Transform given integer value. If the curve consist of more than one curve, the
//      first curve is used for transforming. The second and third curves has no effect.
// p3: Integer[], value to be transformed.

R3CURVM_TRANSFORM_I = 49000;

function mR3CURVM_TRANSFORM_I(p3) {
  DoA(this.r3obj, 49000, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Transform given R3FLOAT
// p3: Number, float value to be transformed

R3CURVM_TRANSFORM_F = 49001;

function mR3CURVM_TRANSFORM_F(p3) {
  DoA(this.r3obj, 49001, p3, R3TID_FLOAT, 0);
}

// Description: Transform vector value.
// p3: r3Vect, vector to be transformed

R3CURVM_TRANSFORM_V = 49002;

function mR3CURVM_TRANSFORM_V(p3) {
  DoA(this.r3obj, 49002, p3, R3TID_VECTOR, 0);
}

// Description: Transform R3FLOATCOLOR3 value
// p3: r3Vect, color to be transformed

R3CURVM_TRANSFORM_C = 49003;

function mR3CURVM_TRANSFORM_C(p3) {
  DoA(this.r3obj, 49003, p3, R3TID_COLOR_RGB, 0);
}

// Description: Transform float value using ordnum defining the curve to be used.
// p1: Number, float to be transformed
// p3: Integer, ordnum of the curve 0, 1, 2.

R3CURVM_TRANSFORM_FN = 49004;

function mR3CURVM_TRANSFORM_FN(p1, p3) {
  DoA2(this.r3obj, 49004, p1, R3TID_FLOAT, 0, p3, R3TID_INTEGER, 0);
}

// Description: Make all curves 'flat' - all points will get y coordinate of the first
//      point.
// p3: Integer, sub curve disable bits (e.g. 3 = two first sub curves won't change)

R3CURVM_FLATLINES = 49005;

function mR3CURVM_FLATLINES(p3) {
  DoA(this.r3obj, 49005, p3, R3TID_INTEGER, 0);
}

// Description: Adds new point into the curve provided the curve doesn't already pass through the
//      given point.
// Returns: Boolean, returns true if point was added, false if not
// p1: Integer, type id R3TID_FLOAT, R3TID_VECTOR, R3TID_VECTOR4, R3TID_INTEGER, R3TID_BOOLEAN, R3TID_ENUM
// p2: Object, x value, parameter type must correspond to type id specified in p1
// p3: Object, y value, parameter type must correspond to type id specified in p1

R3CURVM_ADDPOINTIFNOTONLINE = 49006;

function mR3CURVM_ADDPOINTIFNOTONLINE(p1, p2, p3) {
  return   DoA3(this.r3obj, 49006, p1, R3TID_INTEGER, 0, p2, R3TID_OBJECT, 0, p3, R3TID_OBJECT, 0);
}

// Description: Adds new point into the curve provided the curve passes through the point.
// Returns: Boolean, returns true if point was added, false if not.
// p1: Integer, type id R3TID_FLOAT, R3TID_VECTOR, R3TID_VECTOR4, R3TID_INTEGER, R3TID_BOOLEAN, R3TID_ENUM
// p2: Object, x value, parameter type must correspond to type id specified in p1
// p3: Object, y value, parameter type must correspond to type id specified in p1

R3CURVM_ADDPOINTIFONLINE = 49007;

function mR3CURVM_ADDPOINTIFONLINE(p1, p2, p3) {
  return   DoA3(this.r3obj, 49007, p1, R3TID_INTEGER, 0, p2, R3TID_OBJECT, 0, p3, R3TID_OBJECT, 0);
}


R3CURVM_ADDPOINT = 49008;

function mR3CURVM_ADDPOINT() {
  DoA(this.r3obj, 49008, 0, R3TID_INTEGER, 0);
}

// Description: Evaluate curve to drawable polygon in XY points.
// Returns: Integer, number of evaluated points
// p1: Integer, curve index (0, 1, 2)
// p2: r3Vect, result points
// p3: Integer, buffer size, maximum number of points to be evaluated

R3CURVM_EVALXYPOINTS = 49009;

function mR3CURVM_EVALXYPOINTS(p1, p2, p3) {
  return   DoA3(this.r3obj, 49009, p1, R3TID_INTEGER, 0, p2, R3TID_VECTOR, 0, p3, R3TID_INTEGER, 0);
}

// Description: Derive curve.
// p1: r3Vect, parameter value
// p3: r3Vect, result

R3CURVM_DERIVE = 49010;

function mR3CURVM_DERIVE(p1, p3) {
  DoA2(this.r3obj, 49010, p1, R3TID_VECTOR, 0, p3, R3TID_VECTOR, 0);
}

// Description: Set derivative of the curve. The curve points will be modified so that the
//      given derivative achieved.
// p1: r3Vect, parameter value
// p2: Integer, sub curve disable bits
// p3: r3Vect, derivative correspondin the parameter value.

R3CURVM_SETDERIVATIVE = 49011;

function mR3CURVM_SETDERIVATIVE(p1, p2, p3) {
  DoA3(this.r3obj, 49011, p1, R3TID_VECTOR, 0, p2, R3TID_INTEGER, 0, p3, R3TID_VECTOR, 0);
}

// Description: Transform vector value.
// p3: r3Vect4, vector to be transformed

R3CURVM_TRANSFORM_V4 = 49012;

function mR3CURVM_TRANSFORM_V4(p3) {
  DoA(this.r3obj, 49012, p3, R3TID_VECTOR4, 0);
}

// Description: Transform R3FLOATCOLOR value
// p3: r3Vect4, color to be transformed

R3CURVM_TRANSFORM_C4 = 49013;

function mR3CURVM_TRANSFORM_C4(p3) {
  DoA(this.r3obj, 49013, p3, R3TID_COLOR_RGBA, 0);
}

// Description: Scale all X values of points with given factor
// p1: Number, center of scaling
// p2: Integer, sub curve disable bits (0=scale all)
// p3: Number, scaling factor

R3CURVM_SCALEPOINTSX = 49014;

function mR3CURVM_SCALEPOINTSX(p1, p2, p3) {
  DoA3(this.r3obj, 49014, p1, R3TID_FLOAT, 0, p2, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Adds a new point to given x value by copying the y value of
//      first point
// p1: Integer, sub curve disable bits (0=scale all)
// p3: Number, parameter (=x) value where to add the point

R3CURVM_ADDFIRSTTOEND = 49015;

function mR3CURVM_ADDFIRSTTOEND(p1, p3) {
  DoA2(this.r3obj, 49015, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Adds a new point to given x value by copying the y value of
//      the last point
// p1: Integer, sub curve disable bits (0=scale all)
// p3: Number, parameter (=x) value where to add the point

R3CURVM_ADDLASTTOBEGINNING = 49016;

function mR3CURVM_ADDLASTTOBEGINNING(p1, p3) {
  DoA2(this.r3obj, 49016, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Remove unnecessary points.
// p3: Integer, mask bits defining which sub curves should be skipped (0=simplify all)

R3CURVM_SIMPLIFY = 49019;

function mR3CURVM_SIMPLIFY(p3) {
  DoA(this.r3obj, 49019, p3, R3TID_INTEGER, 0);
}

// Description: Set currently active point
// p1: Integer, curve index
// p2: Integer, point index
// p3: Boolean, TRUE sets FALSE resets

R3CURVM_SETACTIVE = 49020;

function mR3CURVM_SETACTIVE(p1, p2, p3) {
  DoA3(this.r3obj, 49020, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_BOOLEAN, 0);
}

// Description: Scale and translate all X values of points: new_x = old_x*scale + translate
// p1: Number, translate
// p2: Integer, disable bits
// p3: Number, scale

R3CURVM_TRANSFORMPOINTSX = 49021;

function mR3CURVM_TRANSFORMPOINTSX(p1, p2, p3) {
  DoA3(this.r3obj, 49021, p1, R3TID_FLOAT, 0, p2, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Unselect all points of given sub curves
// p3: Integer, disable bits - if 0 all points of all sub curves become unselected

R3CURVM_UNSELECTALL = 49022;

function mR3CURVM_UNSELECTALL(p3) {
  DoA(this.r3obj, 49022, p3, R3TID_INTEGER, 0);
}

// Description: Select points 'very near' the given x coordinate
// Returns: Boolean, TRUE if points became selected
// p1: Integer, disable bits. If 0 all sub curves checked
// p3: Number, x coordinate

R3CURVM_SELECTBYX = 49023;

function mR3CURVM_SELECTBYX(p1, p3) {
  return   DoA2(this.r3obj, 49023, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Translate curve points in x direction.
// p1: Integer, disable bits,
// p3: Number, delta

R3CURVM_TRANSLATESELECTEDX = 49024;

function mR3CURVM_TRANSLATESELECTEDX(p1, p3) {
  DoA2(this.r3obj, 49024, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Delete select points
// p3: Integer, sub curve disable bits: 0=delete from all curves

R3CURVM_DELETESELECTEDPOINTS = 49025;

function mR3CURVM_DELETESELECTEDPOINTS(p3) {
  DoA(this.r3obj, 49025, p3, R3TID_INTEGER, 0);
}

// Description: Set x coordinate for the selected points.
// p1: Integer, disable bits
// p3: Number, new x value

R3CURVM_SETSELECTEDX = 49026;

function mR3CURVM_SETSELECTEDX(p1, p3) {
  DoA2(this.r3obj, 49026, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Delete all curve points

R3CURVM_DELETEALLPOINTS = 49027;

function mR3CURVM_DELETEALLPOINTS() {
  DoA(this.r3obj, 49027, 0, R3TID_INTEGER, 0);
}

// Description: Set new min / max limits for the curve. If R3CURVA_Rescale is TRUE,    * curve
//      points are scaled accordingly.
// p3: Tag[], tag list specifying the following tags: R3CURVA_MaxX, R3CURVA_MinX, R3CURVA_MaxY, R3CURVA_MinY, R3CURVA_Rescale.

R3CURVM_SETMINMAX = 49028;

function mR3CURVM_SETMINMAX(p3) {
  Do(this.r3obj, 49028, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: Duplicate selected points
// p1: Integer, disable bits
// p3: Boolean, if true, newly created points are selected

R3CURVM_DUPLICATESELECTEDPOI = 49029;

function mR3CURVM_DUPLICATESELECTEDPOI(p1, p3) {
  DoA2(this.r3obj, 49029, p1, R3TID_INTEGER, 0, p3, R3TID_BOOLEAN, 0);
}

// p1: Integer, disable bits
// p3: Number, delta

R3CURVM_TRANSLATESELECTEDXFR = 49030;

function mR3CURVM_TRANSLATESELECTEDXFR(p1, p3) {
  DoA2(this.r3obj, 49030, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: private

R3CURVM_SHAPECHANGED = 49031;

function mR3CURVM_SHAPECHANGED() {
  DoA(this.r3obj, 49031, 0, R3TID_INTEGER, 0);
}

// Description: Checks if point is active
// Returns: Boolean, TRUE if selected
// p1: Integer, curve index
// p3: Integer, point index

R3CURVM_ISACTIVE = 49032;

function mR3CURVM_ISACTIVE(p1, p3) {
  return   DoA2(this.r3obj, 49032, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Set y coordinate for the selected points
// p1: Integer, disable bits
// p3: Number, new y value

R3CURVM_SETSELECTEDY = 49033;

function mR3CURVM_SETSELECTEDY(p1, p3) {
  DoA2(this.r3obj, 49033, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Copies selection states from a given list to a sub curve
// p1: Integer, sub curve index
// p3: r3List, see R3CURVEPOINT nodes below

R3CURVM_SELECTBYLIST = 49034;

function mR3CURVM_SELECTBYLIST(p1, p3) {
  DoA2(this.r3obj, 49034, p1, R3TID_INTEGER, 0, p3, R3TID_LIST, 0);
}

// Description: Translate selected points
// p1: Integer, disable bits
// p2: Boolean, if TRUE points are not moved outside R3CURVA_MinX... limits
// p3: Number, array of two floats deltax & deltay

R3CURVM_TRANSLATESELECTED = 49035;

function mR3CURVM_TRANSLATESELECTED(p1, p2, p3) {
  DoA3(this.r3obj, 49035, p1, R3TID_INTEGER, 0, p2, R3TID_BOOLEAN, 0, p3, R3TID_FLOAT, 0);
}

// Description: Insert new point to a curve.
// Returns: Boolean, TRUE if point was added
// p1: Number, array of x values (must match current R3CURVA_NCurves count)
// p2: Number, array of y values

R3CURVM_ADDPOINTGENERAL = 49036;

function mR3CURVM_ADDPOINTGENERAL(p1, p2) {
  return   DoA3(this.r3obj, 49036, p1, R3TID_FLOAT, 0, p2, R3TID_FLOAT, 0, 0, R3TID_INTEGER, 0);
}

// Description: align selected points into a line from first selected to last selected point
// p3: Integer, disable bits

R3CURVM_ALIGNSELECTEDPOINTS = 49037;

function mR3CURVM_ALIGNSELECTEDPOINTS(p3) {
  DoA(this.r3obj, 49037, p3, R3TID_INTEGER, 0);
}

// Description: Sets the point geometry, does not change selection.
// p3: Tag[], tag list containing R3CURVA_Points, R3CURVA_Points1, R3CURVA_Points2, R3CURVA_Points3.

R3CURVM_SETPOINTGEOMETRY = 49038;

function mR3CURVM_SETPOINTGEOMETRY(p3) {
  Do(this.r3obj, 49038, p3, R3TID_TAG, R3TNF_ARRAY);
}

// Description: selects a point by sub curve and knot index
// p1: Integer, sub curve index
// p3: Integer, knot index

R3CURVM_SELECTBYINDEX = 49039;

function mR3CURVM_SELECTBYINDEX(p1, p3) {
  DoA2(this.r3obj, 49039, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Find next point closest to the given x value. The passed x value    * will
//      be replaced by the x coord. of the next key.
// Returns: Boolean, true if found, false if not.
// p3: Number, x value

R3CURVM_GETNEXTPOINTBYX = 49040;

function mR3CURVM_GETNEXTPOINTBYX(p3) {
  return   DoA(this.r3obj, 49040, p3, R3TID_FLOAT, 0);
}

// Description: Find previous point closest to the given x value. The passed x value    * will
//      be replaced by the x coord. of the next key.
// Returns: Boolean, true if found, false if not.
// p3: Number, x value

R3CURVM_GETPREVPOINTBYX = 49041;

function mR3CURVM_GETPREVPOINTBYX(p3) {
  return   DoA(this.r3obj, 49041, p3, R3TID_FLOAT, 0);
}

// Description: Select curves within the given X range
// Returns: Integer, number of points selected
// p1: Integer, mask specifying disabled curves
// p3: Number, end value

R3CURVM_SELECTRANGE = 49042;

function mR3CURVM_SELECTRANGE(p1, p3) {
  return   DoA2(this.r3obj, 49042, p1, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Shift curves to start from origin in y dimension
// p3: Integer, disabled mask

R3CURVM_SHIFTTOORIGINY = 49043;

function mR3CURVM_SHIFTTOORIGINY(p3) {
  DoA(this.r3obj, 49043, p3, R3TID_INTEGER, 0);
}




R3CURVA_Points = 49500;
function SetR3CURVA_Points(value) {
  R3Set(this.r3obj, R3CURVA_Points, value, R3TID_LIST, R3TNF_ARRAY);
}

function GetR3CURVA_Points() {
  return R3Get(this.r3obj, R3CURVA_Points, R3TID_LIST, R3TNF_ARRAY);
}

R3CURVA_Points1 = 49501;
function SetR3CURVA_Points1(value) {
  R3Set(this.r3obj, R3CURVA_Points1, value, R3TID_LIST, R3TNF_ARRAY);
}

function GetR3CURVA_Points1() {
  return R3Get(this.r3obj, R3CURVA_Points1, R3TID_LIST, R3TNF_ARRAY);
}

R3CURVA_Points2 = 49502;
function SetR3CURVA_Points2(value) {
  R3Set(this.r3obj, R3CURVA_Points2, value, R3TID_LIST, R3TNF_ARRAY);
}

function GetR3CURVA_Points2() {
  return R3Get(this.r3obj, R3CURVA_Points2, R3TID_LIST, R3TNF_ARRAY);
}

R3CURVA_Points3 = 49503;
function SetR3CURVA_Points3(value) {
  R3Set(this.r3obj, R3CURVA_Points3, value, R3TID_LIST, R3TNF_ARRAY);
}

function GetR3CURVA_Points3() {
  return R3Get(this.r3obj, R3CURVA_Points3, R3TID_LIST, R3TNF_ARRAY);
}

R3CURVA_NCurves = 49504;
function SetR3CURVA_NCurves(value) {
  R3Set(this.r3obj, R3CURVA_NCurves, value, R3TID_INTEGER, 0);
}

function GetR3CURVA_NCurves() {
  return R3Get(this.r3obj, R3CURVA_NCurves, R3TID_INTEGER, 0);
}

R3CURVA_NumPoints = 49505;
function SetR3CURVA_NumPoints(value) {
  R3Set(this.r3obj, R3CURVA_NumPoints, value, R3TID_INTEGER, 0);
}

R3CURVA_MaxX = 49506;
function SetR3CURVA_MaxX(value) {
  R3Set(this.r3obj, R3CURVA_MaxX, value, R3TID_FLOAT, 0);
}

function GetR3CURVA_MaxX() {
  return R3Get(this.r3obj, R3CURVA_MaxX, R3TID_FLOAT, 0);
}

R3CURVA_MinX = 49507;
function SetR3CURVA_MinX(value) {
  R3Set(this.r3obj, R3CURVA_MinX, value, R3TID_FLOAT, 0);
}

function GetR3CURVA_MinX() {
  return R3Get(this.r3obj, R3CURVA_MinX, R3TID_FLOAT, 0);
}

R3CURVA_MaxY = 49508;
function SetR3CURVA_MaxY(value) {
  R3Set(this.r3obj, R3CURVA_MaxY, value, R3TID_FLOAT, 0);
}

function GetR3CURVA_MaxY() {
  return R3Get(this.r3obj, R3CURVA_MaxY, R3TID_FLOAT, 0);
}

R3CURVA_MinY = 49509;
function SetR3CURVA_MinY(value) {
  R3Set(this.r3obj, R3CURVA_MinY, value, R3TID_FLOAT, 0);
}

function GetR3CURVA_MinY() {
  return R3Get(this.r3obj, R3CURVA_MinY, R3TID_FLOAT, 0);
}

R3CURVA_Type = 49510;
function SetR3CURVA_Type(value) {
  R3Set(this.r3obj, R3CURVA_Type, value, R3TID_INTEGER, 0);
}

function GetR3CURVA_Type() {
  return R3Get(this.r3obj, R3CURVA_Type, R3TID_INTEGER, 0);
}

R3CURVA_PointCount0 = 49511;
function GetR3CURVA_PointCount0() {
  return R3Get(this.r3obj, R3CURVA_PointCount0, R3TID_INTEGER, 0);
}

R3CURVA_PointCount1 = 49512;
function GetR3CURVA_PointCount1() {
  return R3Get(this.r3obj, R3CURVA_PointCount1, R3TID_INTEGER, 0);
}

R3CURVA_PointCount2 = 49513;
function GetR3CURVA_PointCount2() {
  return R3Get(this.r3obj, R3CURVA_PointCount2, R3TID_INTEGER, 0);
}

R3CURVA_PointCount3 = 49514;
function GetR3CURVA_PointCount3() {
  return R3Get(this.r3obj, R3CURVA_PointCount3, R3TID_INTEGER, 0);
}

R3CURVA_IsQuaternion = 49515;
function SetR3CURVA_IsQuaternion(value) {
  R3Set(this.r3obj, R3CURVA_IsQuaternion, value, R3TID_INTEGER, 0);
}

function GetR3CURVA_IsQuaternion() {
  return R3Get(this.r3obj, R3CURVA_IsQuaternion, R3TID_INTEGER, 0);
}

R3CURVA_AlsoChangesObj = 49516;
function SetR3CURVA_AlsoChangesObj(value) {
  R3Set(this.r3obj, R3CURVA_AlsoChangesObj, value, R3TID_OBJECT, 0);
}

R3CURVA_AlsoChangesMth = 49517;
function SetR3CURVA_AlsoChangesMth(value) {
  R3Set(this.r3obj, R3CURVA_AlsoChangesMth, value, R3TID_INTEGER, 0);
}

R3CURVA_NewKeyTolerance = 49518;
function SetR3CURVA_NewKeyTolerance(value) {
  R3Set(this.r3obj, R3CURVA_NewKeyTolerance, value, R3TID_FLOAT, 0);
}

function GetR3CURVA_NewKeyTolerance() {
  return R3Get(this.r3obj, R3CURVA_NewKeyTolerance, R3TID_FLOAT, 0);
}

var R3CURVA_Rescale = 49519; // Boolean
R3CURVA_PrepareChangesMth = 49520;
function SetR3CURVA_PrepareChangesMth(value) {
  R3Set(this.r3obj, R3CURVA_PrepareChangesMth, value, R3TID_INTEGER, 0);
}

var R3CURVA_AddPointMask = 49521; // Integer
var R3CURVA_AddPointCondition = 49522; // Integer
var R3CURVA_AddPointTolerance = 49523; // Number[]
R3CURVA_AngleType = 49524;
function SetR3CURVA_AngleType(value) {
  R3Set(this.r3obj, R3CURVA_AngleType, value, R3TID_INTEGER, 0);
}

function GetR3CURVA_AngleType() {
  return R3Get(this.r3obj, R3CURVA_AngleType, R3TID_INTEGER, 0);
}

var R3CAT_NONE = 0;
var R3CAT_HPB = 1;
var R3CAT_HPT = 2;
var R3CUTY_NURBS = 0;
var R3CUTY_POLYLINE = 1;
var R3CUTY_BOOLEAN = 2;
var R3CUTY_NURBS2 = 3;
var R3CUTY_BEZIER = 4;
var R3CAP_ALWAYS = 0;
var R3CAP_IF_ON_LINE = 1;
var R3CAP_IF_NOT_ON_LINE = 2;


function r3Curve () {
   this.base = r3God;
   if(arguments.length) {
      this.base(R3CLID_CURVE, arguments);
   }
   // Methods
   this.TRANSFORM_I=mR3CURVM_TRANSFORM_I;
   this.TRANSFORM_F=mR3CURVM_TRANSFORM_F;
   this.TRANSFORM_V=mR3CURVM_TRANSFORM_V;
   this.TRANSFORM_C=mR3CURVM_TRANSFORM_C;
   this.TRANSFORM_FN=mR3CURVM_TRANSFORM_FN;
   this.FLATLINES=mR3CURVM_FLATLINES;
   this.ADDPOINTIFNOTONLINE=mR3CURVM_ADDPOINTIFNOTONLINE;
   this.ADDPOINTIFONLINE=mR3CURVM_ADDPOINTIFONLINE;
   this.ADDPOINT=mR3CURVM_ADDPOINT;
   this.EVALXYPOINTS=mR3CURVM_EVALXYPOINTS;
   this.DERIVE=mR3CURVM_DERIVE;
   this.SETDERIVATIVE=mR3CURVM_SETDERIVATIVE;
   this.TRANSFORM_V4=mR3CURVM_TRANSFORM_V4;
   this.TRANSFORM_C4=mR3CURVM_TRANSFORM_C4;
   this.SCALEPOINTSX=mR3CURVM_SCALEPOINTSX;
   this.ADDFIRSTTOEND=mR3CURVM_ADDFIRSTTOEND;
   this.ADDLASTTOBEGINNING=mR3CURVM_ADDLASTTOBEGINNING;
   this.SIMPLIFY=mR3CURVM_SIMPLIFY;
   this.SETACTIVE=mR3CURVM_SETACTIVE;
   this.TRANSFORMPOINTSX=mR3CURVM_TRANSFORMPOINTSX;
   this.UNSELECTALL=mR3CURVM_UNSELECTALL;
   this.SELECTBYX=mR3CURVM_SELECTBYX;
   this.TRANSLATESELECTEDX=mR3CURVM_TRANSLATESELECTEDX;
   this.DELETESELECTEDPOINTS=mR3CURVM_DELETESELECTEDPOINTS;
   this.SETSELECTEDX=mR3CURVM_SETSELECTEDX;
   this.DELETEALLPOINTS=mR3CURVM_DELETEALLPOINTS;
   this.SETMINMAX=mR3CURVM_SETMINMAX;
   this.DUPLICATESELECTEDPOI=mR3CURVM_DUPLICATESELECTEDPOI;
   this.TRANSLATESELECTEDXFR=mR3CURVM_TRANSLATESELECTEDXFR;
   this.SHAPECHANGED=mR3CURVM_SHAPECHANGED;
   this.ISACTIVE=mR3CURVM_ISACTIVE;
   this.SETSELECTEDY=mR3CURVM_SETSELECTEDY;
   this.SELECTBYLIST=mR3CURVM_SELECTBYLIST;
   this.TRANSLATESELECTED=mR3CURVM_TRANSLATESELECTED;
   this.ADDPOINTGENERAL=mR3CURVM_ADDPOINTGENERAL;
   this.ALIGNSELECTEDPOINTS=mR3CURVM_ALIGNSELECTEDPOINTS;
   this.SETPOINTGEOMETRY=mR3CURVM_SETPOINTGEOMETRY;
   this.SELECTBYINDEX=mR3CURVM_SELECTBYINDEX;
   this.GETNEXTPOINTBYX=mR3CURVM_GETNEXTPOINTBYX;
   this.GETPREVPOINTBYX=mR3CURVM_GETPREVPOINTBYX;
   this.SELECTRANGE=mR3CURVM_SELECTRANGE;
   this.SHIFTTOORIGINY=mR3CURVM_SHIFTTOORIGINY;

   // Attributes
   this.GetPoints=GetR3CURVA_Points;
   this.SetPoints=SetR3CURVA_Points;
   this.GetPoints1=GetR3CURVA_Points1;
   this.SetPoints1=SetR3CURVA_Points1;
   this.GetPoints2=GetR3CURVA_Points2;
   this.SetPoints2=SetR3CURVA_Points2;
   this.GetPoints3=GetR3CURVA_Points3;
   this.SetPoints3=SetR3CURVA_Points3;
   this.GetNCurves=GetR3CURVA_NCurves;
   this.SetNCurves=SetR3CURVA_NCurves;
   this.SetNumPoints=SetR3CURVA_NumPoints;
   this.GetMaxX=GetR3CURVA_MaxX;
   this.SetMaxX=SetR3CURVA_MaxX;
   this.GetMinX=GetR3CURVA_MinX;
   this.SetMinX=SetR3CURVA_MinX;
   this.GetMaxY=GetR3CURVA_MaxY;
   this.SetMaxY=SetR3CURVA_MaxY;
   this.GetMinY=GetR3CURVA_MinY;
   this.SetMinY=SetR3CURVA_MinY;
   this.GetType=GetR3CURVA_Type;
   this.SetType=SetR3CURVA_Type;
   this.GetPointCount0=GetR3CURVA_PointCount0;
   this.GetPointCount1=GetR3CURVA_PointCount1;
   this.GetPointCount2=GetR3CURVA_PointCount2;
   this.GetPointCount3=GetR3CURVA_PointCount3;
   this.GetIsQuaternion=GetR3CURVA_IsQuaternion;
   this.SetIsQuaternion=SetR3CURVA_IsQuaternion;
   this.SetAlsoChangesObj=SetR3CURVA_AlsoChangesObj;
   this.SetAlsoChangesMth=SetR3CURVA_AlsoChangesMth;
   this.GetNewKeyTolerance=GetR3CURVA_NewKeyTolerance;
   this.SetNewKeyTolerance=SetR3CURVA_NewKeyTolerance;
   this.SetPrepareChangesMth=SetR3CURVA_PrepareChangesMth;
   this.GetAngleType=GetR3CURVA_AngleType;
   this.SetAngleType=SetR3CURVA_AngleType;
}

r3Curve.prototype=new r3Model;
// r3curve.h_H